package demo1228.am;

/*
12G+512G
12G:运行内存
512:硬盘内存

A:进程：进程指正在运行的程序。确切的来说，当一个程序进入内存运行，
即变成一个进程，进程是处于运行过程中的程序，并且具有一定独立功能。

B:线程：线程是进程中的一个执行单元，负责当前进程中程序的执行，
一个进程中至少有一个线程。一个进程中是可以有多个线程的，
这个应用程序也可以称之为多线程程序。

C:简而言之：一个程序运行后至少有一个进程，一个进程中可以包含多个线程
什么是多线程呢？即就是一个程序中有多个线程在同时执行。

实现线程
第一种实现方式:继承java.lang.Thread类
构造方法:
1.public Thread();
2.public Thread(String name);

成员方法:
1.public final String getName();返回的是线程的名称
2.public void run();
如果该线程是使用独立的 Runnable 运行对象构造的，
则调用该 Runnable 对象的 run 方法；否则，该方法不执行任何操作并返回。
Thread 的子类应该重写该方法。
3.public final void setName(String name);设置线程的名称
4.public void start();
使该线程开始执行；Java 虚拟机调用该线程的 run 方法。
结果是两个线程并发地运行；当前线程（从调用返回给 start 方法）
和另一个线程（执行其 run 方法）。
多次启动一个线程是非法的。特别是当线程已经结束执行后，不能再重新启动。
5.public final void setPriority(int newPriority)
设置优先级.

Thread类中的静态常量:
public static final int MAX_PRIORITY;线程可以具有的最高优先级。
public static final int NORM_PRIORITY;分配给线程的默认优先级。
public static final int MIN_PRIORITY;线程可以具有的最低优先级。


Thread静态方法:
1.public static Thread currentThread();
返回对当前正在执行的线程对象的引用。
第一步
格式:
修饰符 Thread的子类 extends Thread{
   public void run(){
   //设置线程任务
   }
}

第二步:
创新Thread子类对象,调用start()方法,就开启线程.

 */
public class Demo_01 {
    //主方法 主线程
    public static void main(String[] args) {
//        线程的优先级
//        最高优先级
        System.out.println(Thread.MAX_PRIORITY);//10
//        最低优先级
        System.out.println(Thread.MIN_PRIORITY);//1
//        默认优先级
        System.out.println(Thread.NORM_PRIORITY);//5

//        创建thread的子类对象
        SubThread sub = new SubThread("A线程");
        SubThread sub1 = new SubThread("B线程");
//        开启线程前,设置线程优先级
        sub.setPriority(Thread.MAX_PRIORITY);
        sub1.setPriority(Thread.MIN_PRIORITY);
        //设置主线程线程优先级
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
//      开启线程,执行线程任务
        sub.start();
        sub1.start();

        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread()+":"+ i);
        }
    }
}
